﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Globalization;
using System.Windows.Forms;
using System.IO;

namespace prjQlyKinhDoanh
{
    public class Common
    {
        public static bool IsNullOrEmpty(string sValue)
        {
            return (sValue == null) || (sValue.Equals(string.Empty)) || (sValue.Equals(""));
        }

        public static bool Empty(object StringValue)
        {
            string String = (string)StringValue;
            if (String == null || String.Trim().Length == 0)
                return true;

            return false;
        }

        // <summary>
        // Chức năng: Kiểm tra chuỗi nhập vào có phải là số hay không
        // </summary>
        // <param name="stringValue">Kiểu string, giá trị cần kiểm tra</param>
        // <returns>true nếu kiểu số , ngược lại trả lại false</returns>

        public bool IsNumeric(string s)
        {
            try
            {
                Int32.Parse(s);
            }
            catch
            {
                return false;
            }
            return true;
        }

        internal static bool IsNumeric2(string numberString)
        {
            char[] ca = numberString.ToCharArray();
            for (int i = 0; i < ca.Length; i++)
            {
                if (ca[i] > 57 || ca[i] < 48)
                    return false;
            }
            return true;
        }

        internal static bool IsNumeric3(string numberString)
        {
            char[] ca = numberString.ToCharArray();
            for (int i = 0; i < ca.Length; i++)
            {
                if (!char.IsNumber(ca[i]))
                    return false;
            }
            return true;
        }

        public static bool IsNumeric4(object Expression)
        {
            bool isNum;
            double retNum;
            isNum = Double.TryParse(Convert.ToString(Expression), System.Globalization.NumberStyles.Any, System.Globalization.NumberFormatInfo.InvariantInfo, out retNum);
            return isNum;
        }

        // <summary>
        // Chức năng: Xóa dấu phẩy và dấm chấm trong một chuỗi
        // </summary>
        // <param name="stringValue">Kiểu string, giá trị cần kiểm tra</param>
        // <returns>Giá String không có dấu phẩy và dấu chấm</returns>

        public static string ReplaceComDot(string str)
        {
            string str1 = "";
            string str2 = "";
            str1 = Regex.Replace(str.ToString(), ",", "");
            str2 = str1.Replace(".", "");
            return str2;
        }

        // <summary>
        // Chức năng: Kiểm tra chuỗi nhập vào có phải là số nguyên, số thập phân hay không
        // </summary>
        // <param name="stringValue">Kiểu string, giá trị cần kiểm tra</param>
        // <returns>True nếu đúng </returns>

        public static bool IsDecimal(string theValue)
        {
            try
            {
                Convert.ToDouble(theValue);
                return true;
            }
            catch
            {
                return false;
            }
        } //IsDecimal

        public static bool IsInteger32(string theValue)
        {
            try
            {
                Convert.ToInt32(theValue);
                return true;
            }
            catch
            {
                return false;
            }
        } //IsInteger32

        public static bool IsInteger16(string theValue)
        {
            try
            {
                Convert.ToInt16(theValue);
                return true;
            }
            catch
            {
                return false;
            }
        } //IsInteger16


        public static bool IsInteger64(string theValue)
        {
            try
            {
                Convert.ToInt64(theValue);
                return true;
            }
            catch
            {
                return false;
            }
        } //IsInteger64


        // <summary>
        // Chức năng: Chuyển một chuỗi sang giá trị bool
        // </summary>
        // <param name="str">Kiểu string, giá trị cần chuyển</param>
        // <returns>true nếu chuyển được, ngược lại false</returns>

        public static bool BoolValue(string str)
        {
            if (((str != null)) & (str != ""))
            {
                try
                {
                    return System.Boolean.Parse(str);
                }
                catch
                {
                    return false;
                }
                finally
                {
                }
            }
            return false;
        }

        // <summary>
        // Chức năng: Chuyển một chuỗi sang giá trị int
        // </summary>
        // <param name="str">Kiểu string, giá trị cần chuyển</param>
        // <returns>0 nếu bị lỗi, ngược lại trả lại giá trị được chuyển</returns>

        public static int IntValue(string str)
        {
            if ((str != null) && (str != ""))
            {
                return System.Int32.Parse(str);
            }
            return 0;
        }

        public static DateTime DateValue(string str)
        {
            if ((str != null) && (str != ""))
            {
                return System.DateTime.Parse(str);
            }
            return DateTime.Today;
        }

        public static string Int2Str(int intValue)
        {
            return intValue.ToString();
        }

        // <summary>
        // Chức năng: Chuyển một số kiểu double sang string theo định dạng "#,###.##"
        // </summary>
        // <param name="dblValue">Kiểu double, giá trị cần chuyển</param>
        // <returns>chuỗi được chuyển</returns>
        // <remarks>

        public static string Double2Str(double dblValue)
        {
            return dblValue.ToString("N2", (new System.Globalization.CultureInfo("en-US")));
        }

        public static string Dbl2Str(double dblValue)
        {
            return dblValue.ToString("N2", (new System.Globalization.CultureInfo("en-US")));
        }


        // <summary>
        // Chức năng: Chuyển một chuỗi sang giá trị double
        // </summary>
        // <param name="str">Kiểu string, giá trị cần chuyển có định đạng theo chuân en-US(English - United State)</param>
        // <returns>0 nếu bị lỗi, ngược lại trả lại giá trị được chuyển</returns>
        // <remarks>

        // Người tạo: Le Thanh Luong
        // Ngày tạo: 09/10/2007
        // Người sửa cuối: Nguyễn Văn Thuấn
        // Ngày sửa: 20/12/2007
        // </remarks>

        public static double DoubleValue(string str)
        {
            try
            {
                if ((str != null) && (str != ""))
                {
                    return System.Double.Parse(str, new System.Globalization.CultureInfo("en-US"));
                }
                else
                {
                    return 0;
                }
            }
            catch
            {
                return 0;
            }
        }

        // <summary>
        // Chức năng: Kiểm tra xem chuỗi đó có phải là số double không. Theo chuẩn của en-US(English - United States)

        // </summary>
        // <param name="strDouble">Kiểu string</param>
        // <returns>true nếu chuỗi đó không phải là đạng double, ngược lại trả lại giá trị false</returns>
        public static bool ValidateDouble(string strDouble)
        {
            try
            {
                double.Parse(strDouble, new System.Globalization.CultureInfo("en-US"));
                return true;
            }
            catch
            {
                return false;
            }
        }

        //public static string Str2Dbl(string strValue)
        //{
        //    //return System.Double.Parse(strValue);
        //}

        //Lay thu muc hien thoi cua he thong
        public static string GetAppFolderPath()
        {
            //string strStartPath = Environment.CurrentDirectory; 
            string strStartPath = Application.StartupPath;
            if ((strStartPath.EndsWith("\\")))
                strStartPath = strStartPath.Substring(0, strStartPath.Length - 1);
            else if ((strStartPath.EndsWith("Debug")))
                strStartPath = strStartPath.Substring(0, strStartPath.Length - 9);
            else
                strStartPath = strStartPath + "\\";

            return strStartPath;
        }


        public static bool ValidEmail(string strEmail)
        {
            if (strEmail != "")
            {
                System.Text.RegularExpressions.Regex Expression = new System.Text.RegularExpressions.Regex("\\S+@\\S+\\.\\S+");
                if (Expression.IsMatch(strEmail) && !strEmail.Contains(","))
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            return true;
        }

        //TuanLM add 29/03/08
        public static bool ValidWebsite(string strWebsite)
        {
            if (strWebsite != "")
            {
                System.Text.RegularExpressions.Regex Expression = new System.Text.RegularExpressions.Regex("http://+\\S+\\.\\S+");
                if (Expression.IsMatch(strWebsite))
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            return true;
        }
        //~TuanLM add 29/03/08

        //Các hàm về ngày tháng năm

        // <summary>
        // Chức năng: Chuyển một giá trị kiểu DateTime sang chuỗi
        // </summary>
        // <param name="dValue">Kiểu DateTime, giá trị cần chuyển</param>
        // <returns>"" nếu bị lỗi, ngược lại trả lại chuỗi được chuyển</returns>

        public static string Date2String(DateTime dValue)
        {
            if (IsValidDateTime(dValue))
            {
                return dValue.ToString("dd/MM/yyyy");
            }

            return "";
        }

        // <summary>
        // Chức năng: Kiểm tra giá trị ngày tháng có hợp lệ hay không
        // </summary>
        // <param name="dValue">Kiểu DateTime, giá trị cần chuyển</param>
        // <returns>true nếu hợp lệ, ngược lại trả lại false</returns>
        public static bool IsValidDateTime(System.DateTime dValue)
        {
            if ((dValue.CompareTo(System.DateTime.MinValue) > 0))
            {
                if ((dValue.CompareTo(System.DateTime.MaxValue) < 0))
                {
                    return true;
                }
            }

            return false;
        }


        public static string GetCurrentDate()
        {
            string sCurrentDay = System.DateTime.Now.Day.ToString();
            string sCurrentMonth = System.DateTime.Now.Month.ToString();
            string sCurrentYear = System.DateTime.Now.Year.ToString();

            if (sCurrentDay.Length < 2)
                sCurrentDay = "0" + sCurrentDay;
            if (sCurrentMonth.Length < 2)
                sCurrentMonth = "0" + sCurrentMonth;
            while (sCurrentYear.Length < 4)
                sCurrentYear = "0" + sCurrentYear;
            return sCurrentDay + "/" + sCurrentMonth + "/" + sCurrentYear;
        }

        public static string ConvertDate(string sDate)
        {
            string[] arrTemp = sDate.Split(char.Parse("/"));
            if (arrTemp[0].Length < 2)
                arrTemp[0] = "0" + arrTemp[0];
            if (arrTemp[1].Length < 2)
                arrTemp[1] = "0" + arrTemp[1];
            while (arrTemp[2].Length < 4)
                arrTemp[2] = "0" + arrTemp[2];
            return arrTemp[2] + "/" + arrTemp[1] + "/" + arrTemp[0];
        }

        public static System.DateTime ParseDate(string strValue, System.DateTime defaultValue)
        {
            try
            {
                System.Globalization.CultureInfo format = new System.Globalization.CultureInfo("vi-VN", true);
                return System.DateTime.Parse(strValue, format, System.Globalization.DateTimeStyles.NoCurrentDateDefault);
            }
            catch
            {

            }
            return defaultValue;
        }

        public static System.DateTime ParseDate(string strValue)
        {
            return ParseDate(strValue, System.DateTime.MinValue);
        }


        #region Các hàm về ngày tháng năm
        //Lấy ngày từ ngày tháng năm
        public static string GetDayFromDate(string sDate)
        {
            string str = sDate.Substring(0, sDate.IndexOf("/"));
            if (str.Length < 2)
                str = "0" + str;
            return str;
        }

        //Lấy tháng từ ngày tháng năm
        public static string GetMonthFromDate(string sDate)
        {
            string str = sDate.Substring(sDate.IndexOf("/") + 1, sDate.LastIndexOf("/") - sDate.IndexOf("/") - 1);
            if (str.Length < 2)
                str = "0" + str;
            return str;
        }

        //Lấy năm từ ngày tháng năm
        public static string GetYearFromDate(string sDate)
        {
            string str = sDate.Substring(sDate.LastIndexOf("/") + 1, sDate.Length - sDate.LastIndexOf("/") - 1);
            while (str.Length < 4)
                str = "0" + str;
            return str;
        }

        // <summary>
        //  Chức năng: Kiểm tra năm có nhuận
        // </summary>
        // <param name="yyyy">Kiểu int, năm cần kiểm tra</param>
        // <returns>true nếu năm nhuận, ngược lại false</returns>

        public static bool IsLeapYear(int yyyy)
        {

            if ((yyyy % 4 == 0 && yyyy % 100 != 0) || (yyyy % 400 == 0))
                return true;
            else
                return false;
        }

        // <summary>
        //  Chức năng: Lấy ngày cuối cùng của tháng trong năm
        // </summary>
        // <param name="iMonth">Kiểu int, tháng cần lấy</param>
        // <param name="iYear">Kiểu int, năm cần lấy</param>
        // <returns>Ngày cuối cùng của tháng trong năm</returns>

        public static int LastDayInMonth(int iMonth, int iYear)
        {
            if (iMonth == 1 || iMonth == 3 || iMonth == 5 || iMonth == 7 || iMonth == 8 || iMonth == 10 || iMonth == 12)
                return 31;
            else if (iMonth == 4 || iMonth == 6 || iMonth == 9 || iMonth == 11)
                return 30;
            else
                return IsLeapYear(iYear) ? 29 : 28;
        }

        // <summary>
        //  Chức năng: Kiểm tra ngày tháng năm có hợp lệ hay không
        // </summary>
        // <param name="sDateToCheck">Kiểu string, ngày tháng cần kiểm tra</param>
        // <returns>true nếu hợp lệ, ngược lại false</returns>

        public static bool IsValidDate(string sDateToCheck)
        {
            try
            {
                int dayTemp = IntValue(GetDayFromDate(sDateToCheck).ToString());
                int monthTemp = IntValue(GetMonthFromDate(sDateToCheck).ToString());
                int yearTemp = IntValue(GetYearFromDate(sDateToCheck).ToString());

                if (yearTemp > 9999 || yearTemp < 1753 || monthTemp > 12 || monthTemp < 1 || dayTemp > LastDayInMonth(monthTemp, yearTemp) || dayTemp < 1)
                {
                    return false;
                }
            }
            catch
            {
                return false;
            }
            return true;
        }

        // <summary>
        //  Chức năng: So sanh voi ngay hien tai
        // </summary>
        // <param name="sDateToCheck">Kiểu string, ngày tháng cần kiểm tra</param>
        // <returns>1: lon hon, -1: nho hon, 0: bang voi ngay hien tai</returns>

        public static int CompareToCurrentDate(string sDateToCheck)
        {
            int intCurrentDay = int.Parse(System.DateTime.Now.Day.ToString());
            int iCurrentMonth = int.Parse(System.DateTime.Now.Month.ToString());
            int iCurrentYear = int.Parse(System.DateTime.Now.Year.ToString());
            int dayTemp = IntValue(GetDayFromDate(sDateToCheck).ToString());
            int monthTemp = IntValue(GetMonthFromDate(sDateToCheck).ToString());
            int yearTemp = IntValue(GetYearFromDate(sDateToCheck).ToString());

            if (yearTemp > iCurrentYear)
                return 1;
            else if (yearTemp < iCurrentYear)
                return -1;
            else if (monthTemp > iCurrentMonth)
                return 1;
            else if (monthTemp < iCurrentMonth)
                return -1;
            else if (dayTemp > intCurrentDay)
                return 1;
            else if (dayTemp < intCurrentDay)
                return -1;
            else
                return 0;
        }
        #endregion

        #region "KeyPress_TextBox"
        private const string strChacracterVN = "ÁÀẢÃẠĂẮẰẲẴẶÂẤẦẨẨẬÒÓỎÕỌƠỜỚỞỠỢÔỐỒỔỖỘÚÙỦŨỤƯỨỪỬỮỰÉÈẺẼẸÊẾỀỂỄỆÍÌỈĨỊÝỲỶỸỴĐ";
        private const string strChactacterA_Z = "asdfghjklqwertyuiopzxcvbnm";
        private const string strChacracterNumber = "0123456789";
        public enum strValidate : byte
        {
            STR_TOLOWER = 0,
            STR_TOUPPER,
            STR_ISNUMBER,
            STR_ISDOUBLE,
            STR_CHAR_A_Z_a_z,
            STR_CHAR_A_Z_a_z_SPACE,
            STR_CHAR_A_Z_a_z_0_9,
            STR_CHAR_A_Z_a_z_0_9_AND_,
            STR_CHAR_A_Z_a_z_VN_SPACE,
            STR_CHAR_A_Z_a_z_VN_0_9_SPACE,
            STR_NOT_TWO_SPACE,
            STR_NOT_SPACE,
            STR_PHONE
        }

        private static bool Like(string str1, string str2, string str3)
        {
            bool isCheck = false;
            if (string.Compare(str1, str2) < 0 || string.Compare(str1, str3) > 0)
                isCheck = false;
            else
                isCheck = true;

            return isCheck;
        }

        public static void ValdateCharInTextBox_Keypress(ref object sender, ref System.Windows.Forms.KeyPressEventArgs e, strValidate OptionValidate)
        {
            if (string.Compare(sender.GetType().ToString(), "System.Windows.Forms.TextBox") != 0) return;

            System.Windows.Forms.TextBox txt;
            txt = (System.Windows.Forms.TextBox)sender;

            switch (OptionValidate)
            {
                case strValidate.STR_TOLOWER:
                    {
                        if (!char.IsControl(e.KeyChar))
                        {
                            e.KeyChar = char.Parse(e.KeyChar.ToString().ToLower());
                            return;
                        }
                        break;
                    }
                case strValidate.STR_TOUPPER:
                    {
                        if (!char.IsControl(e.KeyChar))
                        {
                            e.KeyChar = char.Parse(e.KeyChar.ToString().ToUpper());
                            return;
                        }
                        break;
                    }
                case strValidate.STR_CHAR_A_Z_a_z_0_9_AND_:
                    {
                        if (!char.IsControl(e.KeyChar))
                        {
                            if (strChactacterA_Z.IndexOf(e.KeyChar.ToString().ToLower()) < 0 &&
                                strChacracterNumber.IndexOf(e.KeyChar.ToString()) < 0 &&
                                Like(e.KeyChar.ToString(), "-", "-") == false)
                            {
                                e.Handled = true;
                                return;
                            }
                        }

                        break;
                    }

                case strValidate.STR_CHAR_A_Z_a_z_0_9:
                    {
                        if (!char.IsControl(e.KeyChar))
                        {
                            if (strChactacterA_Z.IndexOf(e.KeyChar.ToString().ToLower()) < 0 &&
                                strChacracterNumber.IndexOf(e.KeyChar.ToString()) < 0)
                            {
                                e.Handled = true;
                                return;
                            }
                        }
                        break;
                    }
                case strValidate.STR_ISNUMBER:
                    {
                        if (!char.IsControl(e.KeyChar))
                        {
                            if (strChacracterNumber.IndexOf(e.KeyChar.ToString()) < 0)
                            {
                                e.Handled = true;
                                return;
                            }
                        }
                        break;
                    }
                case strValidate.STR_ISDOUBLE:
                    {
                        if (!char.IsControl(e.KeyChar))
                        {
                            if (strChacracterNumber.IndexOf(e.KeyChar.ToString()) < 0 && e.KeyChar.ToString() != "." && e.KeyChar.ToString() != ",")
                            {
                                e.Handled = true;
                                return;
                            }
                        }
                        break;
                    }
                case strValidate.STR_CHAR_A_Z_a_z:
                    {
                        if (!char.IsControl(e.KeyChar))
                        {
                            if (strChactacterA_Z.IndexOf(e.KeyChar.ToString().ToLower()) < 0)
                            {
                                e.Handled = true;
                                return;
                            }
                        }
                        break;
                    }
                case strValidate.STR_CHAR_A_Z_a_z_SPACE:
                    {
                        if (!char.IsControl(e.KeyChar))
                        {
                            if (strChactacterA_Z.IndexOf(e.KeyChar.ToString().ToLower()) < 0 &&
                                Like(e.KeyChar.ToString(), " ", " ") == false)
                            {
                                e.Handled = true;
                                return;
                            }
                        }
                        break;
                    }
                case strValidate.STR_CHAR_A_Z_a_z_VN_SPACE:
                    {
                        if (!char.IsControl(e.KeyChar))
                        {
                            if (strChactacterA_Z.IndexOf(e.KeyChar.ToString().ToLower()) < 0 &&
                                Like(e.KeyChar.ToString(), " ", " ") == false &&
                                (strChacracterVN.IndexOf(e.ToString()) < 0))
                            {
                                e.Handled = true;
                                return;
                            }
                        }
                        break;
                    }

                case strValidate.STR_CHAR_A_Z_a_z_VN_0_9_SPACE:
                    {
                        if (!char.IsControl(e.KeyChar))
                        {
                            if (strChactacterA_Z.IndexOf(e.KeyChar.ToString().ToLower()) < 0 &&
                                strChacracterNumber.IndexOf(e.KeyChar.ToString()) < 0 &&
                                Like(e.KeyChar.ToString(), " ", " ") == false &&
                                (strChacracterVN.IndexOf(e.ToString()) < 0))
                            {
                                e.Handled = true;
                                return;
                            }
                        }

                        break;
                    }
                case strValidate.STR_PHONE:
                    {
                        if (!char.IsControl(e.KeyChar))
                        {
                            if (Like(e.KeyChar.ToString(), "(", "(") == false &&
                                Like(e.KeyChar.ToString(), ")", ")") == false &&
                                strChacracterNumber.IndexOf(e.KeyChar.ToString()) < 0 &&
                                Like(e.KeyChar.ToString(), "+", "+") == false &&
                                Like(e.KeyChar.ToString(), "-", "-") == false &&
                                Like(e.KeyChar.ToString(), ".", ".") == false)
                            {
                                e.Handled = true;
                                return;
                            }
                        }

                        break;
                    }
                case strValidate.STR_NOT_SPACE:
                    {
                        if (!char.IsControl(e.KeyChar))
                        {
                            if (e.KeyChar.ToString() == " ")
                            {
                                e.Handled = true;
                                return;
                            }
                        }

                        break;
                    }
                case strValidate.STR_NOT_TWO_SPACE:
                    {
                        Int16 iPos;
                        string str = txt.Text;

                        iPos = (Int16)txt.SelectionStart;
                        if (e.KeyChar == char.Parse(" "))
                        {
                            if (str.Trim().Length == 0)
                            {
                                e.Handled = true;
                                return;
                            }
                            else if (str.Trim().Length > 0)
                            {
                                if (iPos == 0)
                                {
                                    e.Handled = true;
                                    return;
                                }
                                else if (iPos > 0)
                                {
                                    if (iPos < str.Length)
                                    {

                                        if (str.Substring(iPos - 1, 1) == " " | str.Substring(iPos, 1) == " ")
                                        {
                                            e.Handled = true;
                                            return;
                                        }
                                    }
                                    else
                                    {
                                        if (str.Substring(iPos - 1, 1) == " ")
                                        {
                                            e.Handled = true;
                                            return;
                                        }
                                    }
                                }
                            }
                        }
                        break;
                    }
            }
        }

        public static void FirstCharacterToUpper(System.Windows.Forms.TextBox objTexbox)
        {
            int iseleStat;
            string str;
            str = objTexbox.Text;
            iseleStat = objTexbox.SelectionStart;
            while (str.IndexOf("  ") >= 0)
            {
                str = str.Replace("  ", " ");
                iseleStat -= 1;
            }

            string[] arr;
            arr = str.Split(char.Parse(" "));
            for (short i = 0; i <= arr.Length - 1; i++)
            {
                if (arr[i].Length == 1)
                {
                    arr[i] = arr[i].ToUpper();
                }
                else if (arr[i].Length > 1)
                {
                    arr[i] = arr[i].Substring(0, 1).ToUpper() + arr[i].Substring(1).ToLower();
                }
            }
            objTexbox.Text = string.Join(" ", arr);
            objTexbox.SelectionStart = iseleStat;
        }
        #endregion

        #region "KeyPress_TextBox"
        
        public static void txtMa_KeyPress(object sender, KeyPressEventArgs e)
        {
            try
            {
                Common.ValdateCharInTextBox_Keypress(ref sender, ref e, Common.strValidate.STR_ISNUMBER);
            }
            catch (Exception ex)
            {
                MessageBox.Show("Lỗi ngoại lệ: " + ex.Message, Declare.titleError, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        public static void txtPhone_KeyPress(object sender, KeyPressEventArgs e)
        {
            try
            {
                Common.ValdateCharInTextBox_Keypress(ref sender, ref e, Common.strValidate.STR_PHONE);
            }
            catch (Exception ex)
            {
                MessageBox.Show("Lỗi ngoại lệ: " + ex.Message, Declare.titleError, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
        //~TuanLM add 30/03/08
        #endregion

        public static string GetFirstAndLastName(string sFullName, ref string FirstName)
        {
            string[] arr;
            string strTemp = "";
            arr = sFullName.Split(char.Parse(" "));

            if (arr.Length == 1)
            {
                FirstName = arr[0];
                return arr[0];
            }
            else
            {
                for (short i = 0; i <= arr.Length - 2; i++)
                {
                    strTemp = strTemp + " " + arr[i];
                }
                FirstName = strTemp.Trim();
                return arr[arr.Length - 1];
            }
        }

        public static string GetFirstName(string sFullName)
        {
            string[] arr;
            arr = sFullName.Split(char.Parse(" "));
            return arr[0];
        }

        public static string GetLastName(string sFullName)
        {
            string[] arr;
            arr = sFullName.Split(char.Parse(" "));
            return arr[arr.Length - 1];
        }

        public static string StringToUpper(string str)
        {
            char[] ch = str.ToCharArray();
            string strTemp = "";
            for (int i = ch.Length - 1; i >= 0; i--)
            {
                strTemp = strTemp + ch[i].ToString().ToUpper();
            }
            return strTemp;
        }

        public static string StandardString(string str)
        {
            str = str.Trim();
            string strTemp = "";
            if (str.Length > 0)
            {
                char[] ch = str.ToCharArray();
                strTemp = ch[0].ToString().ToUpper();
                int i = 1;
                while (i < ch.Length)
                {
                    strTemp = strTemp + ch[i].ToString();
                    if (ch[i].ToString().Equals(","))
                    {
                        while ((ch[i].ToString().Equals(",")) || (ch[i].ToString().Equals(" ")) || (ch[i].ToString().Equals(".")))
                        {
                            i++;
                            strTemp = strTemp + ch[i].ToString().ToUpper();
                        }
                    }
                    i++;
                }
            }
            return strTemp;
        }

        //Chuyen thanh chu in hoa cac ky tu dau sau dau cach
        public static string StandardString2(string str)
        {
            str = str.Trim();
            string strTemp = "";
            if (str.Length > 0)
            {
                char[] ch = str.ToCharArray();
                strTemp = ch[0].ToString().ToUpper();
                int i = 1;
                while (i < ch.Length)
                {
                    strTemp = strTemp + ch[i].ToString();
                    if (ch[i].ToString().Equals(" "))
                    {
                        while ((ch[i].ToString().Equals(" ")) || (ch[i].ToString().Equals(".")))
                        {
                            i++;
                            strTemp = strTemp + ch[i].ToString().ToUpper();
                        }
                    }
                    i++;
                }
            }
            return strTemp;
        }

        public static byte[] GetPhoto(string filePath)
        {
            byte[] photo = null;
            FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);
            BinaryReader br = new BinaryReader(fs);
            photo = br.ReadBytes((int)fs.Length);
            br.Close();
            fs.Close();
            return photo;
        }

        public static void UpdateOrderNumber(DataGridView grvName, int orderColumn)
        {
            if (grvName.Rows.Count > 0)
            {
                for (int i = 0; i <= grvName.Rows.Count - 1; i++)
                {
                    grvName.Rows[i].Cells[orderColumn].Value = i + 1;
                }
            }
        }

        public static void UpdateSex(DataGridView grvName, int iColumn)
        {
            if (grvName.Rows.Count > 0)
            {
                for (int i = 0; i <= grvName.Rows.Count - 1; i++)
                {
                    if (grvName.Rows[i].Cells[iColumn].Value.ToString() != "Nam")
                        grvName.Rows[i].Cells[iColumn].Value = "Nữ";
                }
            }
        }

    }
}
